A GUIDE TO VERSION 3 OF DEC-10 PROLOG
A GUIDE TO VERSION 3 OF DEC-10 PROLOG
A GUIDE TO VERSION 3 OF DEC-10 PROLOG
A GUIDE TO VERSION 3 OF DEC-10 PROLOG
A GUIDE TO VERSION 3 OF DEC-10 PROLOG
Lawrence Byrd, Fernando Pereira, David Warren
Department of Artificial Intelligence
University of Edinburgh
June 1980
1. SUMMARY
1. SUMMARY
1. SUMMARY
1. SUMMARY
1. SUMMARY
The new features introduced by this version of DEC-10 Prolog include an
"incore" compiler (incorporating "tail recursion optimisation"), an improved
set of program development aids, and new evaluable predicates, notably the
'setof' predicate.
2. INCOMPATIBLE CHANGES
2. INCOMPATIBLE CHANGES
2. INCOMPATIBLE CHANGES
2. INCOMPATIBLE CHANGES
2. INCOMPATIBLE CHANGES
The following changes (with respect to the version described in the User's
Guide) may affect existing programs:
1. New evaluable predicates have been introduced (see later sections).
2. The original "internal database" has been superseded by a more
sophisticated version providing recording under a key.
3. The evaluable predicate 'not(P)' has been renamed '\+(P)'.
4. The evaluable predicate 'retractall(P)' has been replaced by
'abolish(F,N)'.
5. The precedence of the operator 'mode' has been increased, operators
':=' and '+:=' have been dropped, and new standard operators have
been added (see later).
6. The end of file marker returned by 'read' is now different (see
below).
7. The character '%' is no longer available as a solo character in
Prolog text.
carriage-return line-feed
carriage-return line-feed
carriage-return line-feed
carriage-return line-feed
8. In character input/output, the sequence carriage-return line-feed
newline
newline
newline
newline
is translated into a newline character.
2
3. THE INCORE COMPILER
3. THE INCORE COMPILER
3. THE INCORE COMPILER
3. THE INCORE COMPILER
3. THE INCORE COMPILER
It is now possible to compile a Prolog program contained in one or more text
files directly into memory, ready for immediate execution. Outwardly the
effect is very similar to the use of 'reconsult' to read-in a program to the
interpreter. Compilation has the advantage that the program runs 10 or 20
times faster, requires much less working storage, and normally occupies rather
less space than interpreted code. In addition, compiled clauses are indexed
(see below). However, against this, compilation itself is several times
slower than "consulting" and most of the debugging aids, such as tracing, are
not applicable to compiled code.
3.1. Calling the Compiler
3.1. Calling the Compiler
3.1. Calling the Compiler
3.1. Calling the Compiler
3.1. Calling the Compiler
To compile a program, use the evaluable predicate:
Files
Files
Files
Files
compile(Files)
Files
Files
Files
Files
where Files is either the name of a file (including the ersatz file 'user') or
a list of file names. The procedures contained in these files will be
compiled. For example:
?- compile([dbase,'extras.pl',user]).
If clauses for some predicate appear in more than one file, the later set
will effectively overwrite the earlier set, ie. 'compile' behaves much like
'reconsult'. The division of the program into separate files does not imply
any module structure - any compiled procedure can call any other. Again,
compare 'reconsult' and contrast the stand-alone compiler.
In general, compiled and interpreted predicates are treated as being quite
separate, even if they have the same name. Thus compiled procedures cannot
automatically be called from interpreted code, nor vice versa. However, if
compiled code contains a call to a predicate for which no compiled procedure
has been supplied, the corresponding interpreted version (if any) will be
called. Also, as usual, all interpreted procedures can be accessed through
the evaluable predicate 'call(←)'.
3.2. Public Declarations
3.2. Public Declarations
3.2. Public Declarations
3.2. Public Declarations
3.2. Public Declarations
To make a compiled procedure accessible from interpreted code (including
directives) it is necessary to declare it to be "public", using the compiler
directive:
Predicates
Predicates
Predicates
Predicates
:-public Predicates.
Predicates Name Arity
Predicates Name Arity
Predicates Name Arity
Predicates Name Arity
where Predicates is either a predicate specification of the form Name/Arity,
or a conjunction of such specifications. For example:
:-public concatenate/3, member/2, ordered/1, go/0.
3
Public declarations may appear anywhere within a compiled file. It is not
necessary for the public declaration to precede the corresponding procedure,
nor even for them to be in the same file.
For public predicates, the compiled procedure overwrites any interpreted
version (cf. 'reconsult'). Similarly, a subsequent 'reconsult' of an
interpreted version will overwrite the compiled version.
When a compiled version of a public procedure is in force, the interpreted
procedure is actually replaced by a clause:
P P
P P
P P
P P
P :- incore(P).
P
P
P
P
where P is the most general goal for that predicate, and where 'incore(←)' is
a standard evaluable predicate, analogous to 'call(←)', through which are
accessible all the compiled procedures for public predicates.
Note that one can therefore effectively extend or modify a public procedure
using 'consult', 'assert's etc., but these changes will only be visible to
interpreted code.
3.3. Mode Declarations
3.3. Mode Declarations
3.3. Mode Declarations
3.3. Mode Declarations
3.3. Mode Declarations
As with the stand-alone compiler, mode declarations may be supplied for
compiled predicates. (This enables the compiler to generate more compact code
making better use of runtime storage). The syntax is slightly extended:
Modes
Modes
Modes
Modes
:-mode Modes.
Modes
Modes
Modes
Modes
where Modes is either the mode specification for a single predicate, or a
conjunction of such specifications, eg.
:-mode concatenate(+,?,-), member(?,+), ordered(+).
3.4. Indexing
3.4. Indexing
3.4. Indexing
3.4. Indexing
3.4. Indexing
As with the stand-alone compiler (and in contrast to the interpreter), the
clauses of a compiled procedure are indexed according to the principal functor
of the first argument in the head. This means that the subset of clauses
which match a given goal, as far as the first step of unification is
concerned, is found very quickly, in practically constant time (ie. in a time
independent of the number of clauses in the procedure). This can be very
important where there is a large number of clauses in a procedure. Indexing
also improves the Prolog system's ability to detect determinacy - important
for conserving working storage.
4
3.5. Tail Recursion Optimisation
3.5. Tail Recursion Optimisation
3.5. Tail Recursion Optimisation
3.5. Tail Recursion Optimisation
3.5. Tail Recursion Optimisation
The incore compiler incorporates a "tail recursion optimisation" to improve
the speed and space efficiency of determinate procedures.
When execution reaches the last goal in a clause belonging to some
procedure, and provided there are no remaining backtrack points in the
execution so far of that procedure, all of the procedure's local working
immediately
immediately
immediately
immediately
storage is immediately reclaimed, and any structures it has created become
eligible for garbage collection. This means that programs can now recurse to
arbitrary depths without necessarily exceeding core limits. For example:
cycle(State) :- transform(State,State1), cycle(State1).
where 'transform' is a determinate procedure can continue executing
indefinitely, provided each individual structure, State, is not too large.
The procedure 'cycle' is equivalent to an iterative loop in a conventional
language.
To take advantage of the tail recursion optimisation one must ensure that
the Prolog system can recognise that the procedure is determinate at the
appropriate point. In general this involves reliance on DEC-10 Prolog's
indexing and/or use of cut.
3.6. Practical Limitations
3.6. Practical Limitations
3.6. Practical Limitations
3.6. Practical Limitations
3.6. Practical Limitations
At present, the space occupied by superseded compiled code is not reclaimed.
Making a predicate public leads to the generation of a significant amount of
extra code. Moreover, at present, this code is re-generated every time
'compile' is called, (and the space occupied by the old code is not
reclaimed). Therefore it is important to include all the files to be compiled
in a single call to 'compile', if at all possible.
You may notice that there is a slight pause on starting and finishing a
compilation. This is because the compiler resides in a separate overlay,
which has to be swapped in and out.
4. PROGRAM DEVELOPMENT AIDS
4. PROGRAM DEVELOPMENT AIDS
4. PROGRAM DEVELOPMENT AIDS
4. PROGRAM DEVELOPMENT AIDS
4. PROGRAM DEVELOPMENT AIDS
For details of the new debugging facilities see the separate paper "DEBUG".
Notice, however, that the evaluable predicates concerned with debugging are
also described below in section 7.8.
5
5. OTHER NEW FEATURES
5. OTHER NEW FEATURES
5. OTHER NEW FEATURES
5. OTHER NEW FEATURES
5. OTHER NEW FEATURES
5.1. Initialisation File
5.1. Initialisation File
5.1. Initialisation File
5.1. Initialisation File
5.1. Initialisation File
When Prolog starts, it looks for file PROLOG.INI in the user's directory,
and consults it if found.
5.2. Terminal prompts
5.2. Terminal prompts
5.2. Terminal prompts
5.2. Terminal prompts
5.2. Terminal prompts
When reading input from the terminal, the system now uses different prompts
to distinguish different levels of the system. The interpreter top level
outputs '| ?- ' before reading the next directive, and the prompt (on
following lines) becomes '| '. When (re)consulting from the terminal the
prompt becomes '| '. During program execution (ie for user input), the prompt
will normally be '|: '. However, this last case can be changed by the user,
during execution, with the evaluable predicate 'prompt' (see below).
When the system asks for a single character response, it will never read
beyond the end of the line; therefore there are no continuation prompts for
these cases. This type of response occurs in three places: at the top level
carriage-return
carriage-return
carriage-return
carriage-return
after the values of variables have been output (";carriage-return" to
carriage-return
carriage-return
carriage-return
carriage-return
backtrack, "carriage-return" to finish); after tracing messages (as described
earlier); and in reply to the interrupt handler. These lines are also
completely flushed up to the end of line. This habit is recommended to users
who perform character I/O from the terminal, otherwise left over characters
(especially end of lines) are apt to be read by the debugging package.
5.3. End of Line Comments
5.3. End of Line Comments
5.3. End of Line Comments
5.3. End of Line Comments
5.3. End of Line Comments
All the term input predicates ('read', 'consult', etc.) treat as a comment
any text between the character '%' and the end of the line, except if the '%'
appears inside a quoted atom, a string, or immediately before a parenthesis.
5.4. Handling of Line Terminators
5.4. Handling of Line Terminators
5.4. Handling of Line Terminators
5.4. Handling of Line Terminators
5.4. Handling of Line Terminators
carriage-return line-feed
carriage-return line-feed
carriage-return line-feed
carriage-return line-feed
In character input, the sequence carriage-return line-feed is read in as the
newline
newline
newline
newline
single character newline, ASCII code 31. This is reversed on output, where
newline carriage-return line-feed
newline carriage-return line-feed
newline carriage-return line-feed
newline carriage-return line-feed
'put'ing newline inserts a carriage-return line-feed sequence in the output
stream.
5.5. End of File Marker
5.5. End of File Marker
5.5. End of File Marker
5.5. End of File Marker
5.5. End of File Marker
The end of file marker returned by 'read' is now the atom 'end←of←file',
instead of the term ':-end', which was returned in earlier versions.
6
6. NEW OPERATORS
6. NEW OPERATORS
6. NEW OPERATORS
6. NEW OPERATORS
6. NEW OPERATORS
The following are new standard operators:
:-op(1150,fx,[mode,public]).
:-op(900,fy,[\+,spy,nospy]).
:-op(700,xfx,[@<,@>,@=<,@>=]).
:-op(200,xfy,[↑]).
and some of the old ones have been dropped. The complete list of standard
operators is now:
:-op( 1200, xfx, [ :-, --> ]).
:-op( 1200, fx, [ :-, ?- ]).
:-op( 1150, fx, [ mode, public ]).
:-op( 1100, xfy, [ ; ]).
:-op( 1050, xfy, [ -> ]).
:-op( 1000, xfy, [ ',' ]).
:-op( 900, fy, [ \+, spy, nospy ]).
:-op( 700, xfx, [ =, is, =.., ==, \==, @<, @>, @=<, @>=,
=:=, =\=, <, >, =<, >= ]).
:-op( 500, yfx, [ +, -, /\, \/ ]).
:-op( 500, fx, [ +, - ]).
:-op( 400, yfx, [ *, /, <<, >> ]).
:-op( 300, xfx, [ mod ]).
:-op( 200, xfy, [ ↑ ]).
7. NEW EVALUABLE PREDICATES
7. NEW EVALUABLE PREDICATES
7. NEW EVALUABLE PREDICATES
7. NEW EVALUABLE PREDICATES
7. NEW EVALUABLE PREDICATES
7.1. Compiled Program
7.1. Compiled Program
7.1. Compiled Program
7.1. Compiled Program
7.1. Compiled Program
Files
Files
Files
Files
compile(Files)
Files
Files
Files
Files
Compiles the file or list of files specified by Files. (See section above
on the incore compiler).
Goal
Goal
Goal
Goal
incore(Goal)
Goal
Goal
Goal
Goal
The term Goal is interpreted as a call to a current public compiled
procedure.
Name Arity
Name Arity
Name Arity
Name Arity
abolish(Name,Arity)
Effectively removes the procedure, either interpreted or public compiled,
Name Arity
Name Arity
Name Arity
Name Arity
for the predicate specified by Name and Arity). cf. the evaluable
predicate 'retractall(←)', which is no longer available.
Name Arity
Name Arity
Name Arity
Name Arity
revive(Name,Arity)
7
Name Arity
Name Arity
Name Arity
Name Arity
If the predicate specified by Name and Arity is public, the current
interpreted procedure (if any) for that predicate is replaced by the most
recent compiled version. Otherwise the call has no effect.
7.2. Interpreted Program etc.
7.2. Interpreted Program etc.
7.2. Interpreted Program etc.
7.2. Interpreted Program etc.
7.2. Interpreted Program etc.
File Files
File Files
File Files
File Files
[File|Files]
This shorthand way of consulting or reconsulting a list of files now has
full status as an evaluable predicate, instead of being just a special
command.
Predicate
Predicate
Predicate
Predicate
listing(Predicate)
Predicate
Predicate
Predicate
Predicate
This evaluable predicate has been extended. The argument Predicate may
Name Arity
Name Arity
Name Arity
Name Arity
now be a predicate specification of the form Name/Arity. The effect is
to produce a listing of the interpreted clauses for the particular
Predicate
Predicate
Predicate
Predicate
predicate specified. If Predicate is just an atom, then the interpreted
procedures for all predicates of that name are listed, as before. In
Predicate
Predicate
Predicate
Predicate
addition, it is possible for Predicate to be a list of predicate
specifications of either type, eg.
:-listing([concatenate/3, reverse, go/0]).
Head Body Ref
Head Body Ref
Head Body Ref
Head Body Ref
clause(Head,Body,Ref)
Head Body Ref
Head Body Ref
Head Body Ref
Head Body Ref
Equivalent to 'clause(Head,Body)' where Ref is an implementation defined
Ref
Ref
Ref
Ref
term which uniquely identifies the clause concerned. If Ref is not given
Head
Head
Head
Head
at the time of the call, Head must be instantiated to a non-variable
term. Thus this predicate can have two different modes of use, depending
on whether the identifier of the clause is known or unknown. Compare
'instance(←,←)'.
Clause Ref
Clause Ref
Clause Ref
Clause Ref
assert(Clause,Ref)
Clause Ref
Clause Ref
Clause Ref
Clause Ref
Equivalent to 'assert(Clause)' where Ref is the implementation defined
identifier of the clause asserted.
Clause Ref
Clause Ref
Clause Ref
Clause Ref
asserta(Clause,Ref)
Clause Ref
Clause Ref
Clause Ref
Clause Ref
Equivalent to 'asserta(Clause)' where Ref is the implementation defined
identifier of the clause asserted.
Clause Ref
Clause Ref
Clause Ref
Clause Ref
assertz(Clause,Ref)
Clause Ref
Clause Ref
Clause Ref
Clause Ref
Equivalent to 'assertz(Clause)' where Ref is the implementation defined
identifier of the clause asserted.
8
7.3. Internal Database
7.3. Internal Database
7.3. Internal Database
7.3. Internal Database
7.3. Internal Database
Key Term Ref
Key Term Ref
Key Term Ref
Key Term Ref
recorded(Key,Term,Ref)
Key
Key
Key
Key
The internal database is searched for terms recorded under the key Key.
Term
Term
Term
Term
These terms are successively unified with Term in the order they occur in
Ref
Ref
Ref
Ref
the database. At the same time, Ref is unified with an implementation
defined term uniquely identifying the recorded item. The key must be
given, and may be an atom, integer or complex term. In the case of a
complex term, only the principal functor is significant.
Key Term Ref
Key Term Ref
Key Term Ref
Key Term Ref
recorda(Key,Term,Ref)
Term
Term
Term
Term
The term Term is recorded in the internal database as the first item for
Key Ref
Key Ref
Key Ref
Key Ref
the key Key, where Ref is its implementation defined identifier. The key
must be given, and only its principal functor is significant.
Key Term Ref
Key Term Ref
Key Term Ref
Key Term Ref
recordz(Key,Term,Ref)
Term
Term
Term
Term
The term Term is recorded in the internal database as the last item for
Key Ref
Key Ref
Key Ref
Key Ref
the key Key, where Ref is its implementation defined identifier. The key
must be given, and only its principal functor is significant.
Ref
Ref
Ref
Ref
erase(Ref)
or
or
or
or
The recorded item or interpreted clause whose implementation defined
Ref
Ref
Ref
Ref
identifier is Ref is effectively erased from the internal database or
interpreted program.
Ref Term
Ref Term
Ref Term
Ref Term
instance(Ref,Term)
A (most general) instance of the recorded term whose implementation
Ref Term
Ref Term
Ref Term
Ref Term
defined identifier is Ref is unified with Term.
7.4. Meta-Logical
7.4. Meta-Logical
7.4. Meta-Logical
7.4. Meta-Logical
7.4. Meta-Logical
Atom
Atom
Atom
Atom
current←atom(Atom)
Generates (through backtracking) all currently known atoms, and returns
Atom
Atom
Atom
Atom
each one as Atom.
Name Functor
Name Functor
Name Functor
Name Functor
current←functor(Name,Functor)
Generates (through backtracking) all currently known functors, and for
Name Functor
Name Functor
Name Functor
Name Functor
each one returns its name and most general term as Name and Functor
Name
Name
Name
Name
respectively. If Name is given, only functors with that name are
generated.
Name Functor
Name Functor
Name Functor
Name Functor
current←predicate(Name,Functor)
9
Similar to 'current←functor', but it only generates functors
corresponding to predicates for which there currently exists an
interpreted procedure.
X P S
X P S
X P S
X P S
setof(X,P,S)
S X P
S X P
S X P
S X P
Read this as "S is the set of all instances of X such that P is provable,
P
P
P
P
where that set is non-empty". The term P specifies a goal or goals as in
P
P
P
P
'call(P)'. A set of terms is represented as a list of those terms,
without duplicates, in the standard order for terms (see Comparison of
X
X
X
X
Terms, below). Note that variables appearing in the term X should not
P
P
P
P
appear anywhere else in the clause except within the term P. Obviously,
the set to be enumerated should be finite, and should be enumerable by
Prolog in finite time. Note that it is possible for the provable
S
S
S
S
instances to contain variables, but in this case the list S will only
provide an imperfect representation of what is in reality an infinite
set.
Note that a call to this evaluable predicate can potentially backtrack,
S
S
S
S
generating alternative values for the non-empty set S, corresponding to
P
P
P
P
different instantiations of the free variables of P. (It is to cater for
S
S
S
S
such usage that the set S is constrained to be non-empty). For example,
the call:
?- setof(X, X likes Y, S).
might produce:
Y = beer, X = [dick, harry, tom]
Y = cider, X = [bill, jan, tom ]
The call:
?- setof((Y,S), setof(X, X likes Y, S), SS).
would then produce:
SS = [ (beer,[dick,harry,tom]), (cider,[bill,jan,tom]) ]
P
P
P
P
Variables occurring in P will not be treated as free if they are
P
P
P
P
explicitly bound within P by an existential quantifier. An existential
quantification is written:
Y Q
Y Q
Y Q
Y Q
Y↑Q
Y Q Y
Y Q Y
Y Q Y
Y Q Y
meaning "there exists a Y such that Q is true", where Y is some Prolog
variable. For example:
?- setof(X, Y↑(X likes Y), S).
would produce the single result:
10
X = [bill, dick, harry, jan, tom]
in contrast to the earlier example.
X P Bag
X P Bag
X P Bag
X P Bag
bagof(X,P,Bag)
X P S
X P S
X P S
X P S
This is exactly the same as 'setof(X,P,S)' except that the list (or
alternative lists) returned will not be ordered, and may contain
duplicates. The effect of this relaxation is to save considerable time
and space in execution.
X P
X P
X P
X P
X↑P
X P
X P
X P
X P
The interpreter recognises this as meaning "there exists an X such that P
P
P
P
P
is true", and treats it as equivalent to 'call(P)'. The use of this
explicit existential quantifier outside the 'setof' and 'bagof'
constructs is superfluous, and therefore is not recognised by the
compiler.
7.5. Comparison of Terms
7.5. Comparison of Terms
7.5. Comparison of Terms
7.5. Comparison of Terms
7.5. Comparison of Terms
The evaluable predicates which follow make reference to a standard total
ordering of terms, which is as follows:
- variables, in a standard order (roughly, oldest first);
- integers, from - "infinity" to + "infinity";
- atoms, in alphabetical (ie. ASCII) order;
- complex terms, ordered first by arity, then by the name of principal
functor, then by the arguments (in left-to-right order).
For example, here is a list of terms in the standard order:
[ X, Y, -9, 1, fie, foe, fum, X = X, X = Y, fie(0,2), fie(1,1) ]
Op T1 T2
Op T1 T2
Op T1 T2
Op T1 T2
compare(Op,T1,T2)
T1 T2 Op
T1 T2 Op
T1 T2 Op
T1 T2 Op
The result of comparing terms T1 and T2 is Op, where the possible values
Op
Op
Op
Op
for Op are:
T1 T2
T1 T2
T1 T2
T1 T2
'=' if T1 is identical to T2,
T1 T2
T1 T2
T1 T2
T1 T2
'<' if T1 is before T2 in the standard order,
T1 T2
T1 T2
T1 T2
T1 T2
'>' if T1 is after T2 in the standard order.
Thus 'compare(=,T1,T2)' is equivalent to 'T1 == T2'.
T1 T2
T1 T2
T1 T2
T1 T2
T1 @< T2
11
T1 T2
T1 T2
T1 T2
T1 T2
Term T1 is before term T2 in the standard order.
T1 T2
T1 T2
T1 T2
T1 T2
T1 @> T2
T1 T2
T1 T2
T1 T2
T1 T2
Term T1 is after term T2 in the standard order.
T1 T2
T1 T2
T1 T2
T1 T2
T1 @=< T2
T1 T2
T1 T2
T1 T2
T1 T2
Term T1 is not after term T2 in the standard order.
T1 T2
T1 T2
T1 T2
T1 T2
T1 @>= T2
T1 T2
T1 T2
T1 T2
T1 T2
Term T1 is not before term T2 in the standard order.
L1 L2
L1 L2
L1 L2
L1 L2
sort(L1,L2)
L1
L1
L1
L1
The elements of the list L1 are sorted into the standard order, and any
L2
L2
L2
L2
identical (ie. '==') elements are merged, yielding the list L2. (The
N N N
N N N
N N N
N N N
time taken to do this is at worst order N log N where N is the length of
L1
L1
L1
L1
L1).
L1 L2
L1 L2
L1 L2
L1 L2
keysort(L1,L2)
L1 Key Value
L1 Key Value
L1 Key Value
L1 Key Value
The list L1 must consist of items of the form Key-Value. These items are
Key L2
Key L2
Key L2
Key L2
sorted into order according to the value of Key, yielding the list L2. No
N N
N N
N N
N N
merging takes place. (The time taken to do this is at worst order N log N
N L1
N L1
N L1
N L1
where N is the length of L1).
7.6. Input-Output
7.6. Input-Output
7.6. Input-Output
7.6. Input-Output
7.6. Input-Output
Term
Term
Term
Term
writeq(Term)
Term
Term
Term
Term
Similar to 'write(Term)', but the names of atoms and functors are quoted
where necessary to make the result acceptable as input to 'read'.
Term
Term
Term
Term
print(Term)
Term Term
Term Term
Term Term
Term Term
Print Term onto the current output. If Term is a variable then it is
Term Term
Term Term
Term Term
Term Term
written, using 'write(Term)'. If Term is non-variable then a call is
Term
Term
Term
Term
made to the user defined procedure 'portray(Term)'. Should 'portray'
Term
Term
Term
Term
fail (or be undefined) then 'write(Term)' will be called, otherwise it
Term
Term
Term
Term
will be assumed that Term has been output. 'print' thus provides a
handle for user defined pretty printing. In particular, the debugging
package 'print's the goals in the tracing messages, and the interpreter
top level 'print's the final values of variables.
12
7.7. Environmental
7.7. Environmental
7.7. Environmental
7.7. Environmental
7.7. Environmental
Old New
Old New
Old New
Old New
prompt(Old,New)
The sequence of characters (prompt) which indicates that the system is
Old
Old
Old
Old
waiting for user input is represented as an atom, and matched to Old; the
New
New
New
New
atom bound to New specifies the new prompt. In particular, the goal
prompt(X,X)
matches the current prompt to X, without changing it.
Precedence Type Op
Precedence Type Op
Precedence Type Op
Precedence Type Op
current←op(Precedence,Type,Op)
Op Type
Op Type
Op Type
Op Type
The atom Op is currently an operator of type Type and precedence
Precedence Op
Precedence Op
Precedence Op
Precedence Op
Precedence. Neither Op nor the other arguments need be instantiated at
the time of the call; ie. this predicate can be used to generate as well
as to test.
7.8. Debugging
7.8. Debugging
7.8. Debugging
7.8. Debugging
7.8. Debugging
debug
Debug mode is switched on. Information will now be retained for debugging
purposes and executions will require more space.
nodebug
Debug mode is switched off. Information is no longer retained for
debugging.
trace
Debug mode is switched on, and an immediate CREEP decision is made, so
that tracing will start with the very next port through which control
passes. Since this is a once-off decision, a call to trace is necessary
whenever tracing is required right from the start of an execution. (The
assumed decision is otherwise LEAP).
Mode
Mode
Mode
Mode
leash(Mode)
Mode
Mode
Mode
Mode
Leashing is set to Mode. This will affect whether or not you are
Mode
Mode
Mode
Mode
prompted after certain tracing messages. Mode can be one of the
following:
full - prompt on call, exit, redo and fail
tight - prompt on call, redo and fail
half - prompt on call and redo
13
loose - prompt on call
off - never prompt
Mode
Mode
Mode
Mode
or Mode can be an integer between 0 and 15 which will set any arbitrary
combination not covered above. (Treat the integer as a binary number
CERF C E R F
CERF C E R F
CERF C E R F
CERF C E R F
2'CERF, where C, E, R and F give the yes/no (1/0) decisions for the call,
exit, redo and fail ports respectively). When a port is unleashed, the
tracing message will still be output and then an automatic CREEP decision
is made. Note that the ports of spy-points are always leashed (and
cannot be unleashed).
Spec
Spec
Spec
Spec
spy Spec
Spec
Spec
Spec
Spec
Spy-points will be placed on all the procedures given by Spec. All
control flow through the ports of these procedures will henceforth be
traced. If debug mode was previously off, then it will be switched on.
Spec Name/Arity
Spec Name/Arity
Spec Name/Arity
Spec Name/Arity
Spec can either be a predicate specification of the form Name/Arity or
Name Name
Name Name
Name Name
Name Name
Name, or a list of such specifications. When the Name is given without
Arity
Arity
Arity
Arity
the Arity this refers to all predicates of that name which currently have
definitions. If there are none, then nothing will be done. Spy-points
can be placed on particular undefined procedures only by using the full
Name/Arity
Name/Arity
Name/Arity
Name/Arity
form, Name/Arity.
Spec
Spec
Spec
Spec
nospy Spec
Spec
Spec
Spec
Spec
Spy-points are removed from all the procedures given by Spec (as for
'spy').
debugging
Outputs information concerning the status of the debugging package. This
will show: whether debug mode is on, and if it is - what spy-points have
been set and what mode of leashing is in force.
7.9. Pre-Processing
7.9. Pre-Processing
7.9. Pre-Processing
7.9. Pre-Processing
7.9. Pre-Processing
T1 T2
T1 T2
T1 T2
T1 T2
expand←term(T1,T2)
When program is read in, some of the terms read are transformed before
T1 T2
T1 T2
T1 T2
T1 T2
being stored as clauses. If T1 is a term that can be transformed, T2 is
T2 T1
T2 T1
T2 T1
T2 T1
the result. Otherwise T2 is just T1 unchanged. The only transformation
currently available translates grammar rules into clauses.
7.10. Grammars
7.10. Grammars
7.10. Grammars
7.10. Grammars
7.10. Grammars
P L
P L
P L
P L
phrase(P,L)
14
L P
L P
L P
L P
The list L is a phrase of type P (according to the current grammar
P
P
P
P
rules), where P is either a non-terminal or more generally a grammar rule
P
P
P
P
body. P must be non-variable.
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES
F N F N
F N F N
F N F N
F N F N
abolish(F,N) Abolish the interpreted procedure named F arity N.
abort Abort execution of the current directive.
L L
L L
L L
L L
ancestors(L) The ancestor list of the current clause is L.
N T A N T A
N T A N T A
N T A N T A
N T A N T A
arg(N,T,A) The Nth argument of term T is A.
C C
C C
C C
C C
assert(C) Assert clause C.
C R
C R
C R
C R
assert( Assert clause C, reference R.
C C
C C
C C
C C
asserta(C) Assert C as first clause.
C R C R
C R C R
C R C R
C R C R
asserta(C,R) Assert C as first clause, reference R.
C C
C C
C C
C C
assertz(C) Assert C as last clause.
C R C R
C R C R
C R C R
C R C R
assertz(C,R) Assert C as last clause, reference R.
T T
T T
T T
T T
atom(T) Term T is an atom.
T T
T T
T T
T T
atomic(T) Term T is an atom or integer.
X P B X P B
X P B X P B
X P B X P B
X P B X P B
bagof(X,P,B) The bag of instances of X such that P is provable is B.
break Break at the next interpreted procedure call.
P P
P P
P P
P P
call(P) Execute the interpreted procedure call P.
P Q P Q
P Q P Q
P Q P Q
P Q P Q
clause(P,Q) There is an interpreted clause, head P, body Q.
P Q R P Q R
P Q R P Q R
P Q R P Q R
P Q R P Q R
clause(P,Q,R) There is an interpreted clause, head P, body Q, ref R.
F F
F F
F F
F F
close(F) Close file F.
C X Y C X Y
C X Y C X Y
C X Y C X Y
C X Y C X Y
compare(C,X,Y) C is the result of comparing terms X and Y.
F F
F F
F F
F F
compile(F) Compile the procedures in text file F.
F F
F F
F F
F F
consult(F) Extend the interpreted program with clauses from file F.
core←image Set up a core image ready to be saved.
A A
A A
A A
A A
current←atom(A) One of the currently defined atoms is A.
A T A T
A T A T
A T A T
A T A T
current←functor(A,T) A current functor is named A, m.g. term T.
A P A P
A P A P
A P A P
A P A P
current←predicate(A,P) A current predicate is named A, m.g. goal P.
P T A A T P
P T A A T P
P T A A T P
P T A A T P
current←op(P,T,A) Atom A is an operator type T precedence P.
debug Switch on debugging.
debugging Output debugging status information.
D D
D D
D D
D D
depth(D) The current invocation depth is D.
T T
T T
T T
T T
display(T) Display term T on the terminal.
R R
R R
R R
R R
erase(R) Erase the clause or record, reference R.
T X T X
T X T X
T X T X
T X T X
expand←term(T,X) Term T is a shorthand which expands to term X.
fail Backtrack immediately.
fileerrors Enable reporting of file errors.
T F N T F N
T F N T F N
T F N T F N
T F N T F N
functor(T,F,N) The principal functor of term T has name F, arity N.
gc Enable garbage collection.
N N
N N
N N
N N
gcguide(N) The desirable GC threshold is N pages.
C C
C C
C C
C C
get(C) The next non-blank character input is C.
C C
C C
C C
C C
get0(C) The next character input is C.
halt Halt Prolog, exit to the monitor.
P P
P P
P P
P P
incore(P) Execute the compiled procedure call P.
R T R T
R T R T
R T R T
R T R T
instance(R,T) A m.g. instance of the record reference R is T.
T T
T T
T T
T T
integer(T) Term T is an integer.
15
Y X Y X
Y X Y X
Y X Y X
Y X Y X
Y is X Y is the value of integer expression X.
L S L S
L S L S
L S L S
L S L S
keysort(L,S) The list L sorted by key yields S.
M M
M M
M M
M M
leash(M) Set leashing mode to M.
L N L N
L N L N
L N L N
L N L N
length(L,N) The length of list L is N.
listing List the current interpreted program.
P P
P P
P P
P P
listing(P) List the interpreted procedure(s) specified by P.
log Enable logging.
D D
D D
D D
D D
maxdepth(D) Limit invocation depth to D.
A L A L
A L A L
A L A L
A L A L
name(A,L) The name of atom or integer A is string L.
nl Output a new line.
nodebug Switch off debugging.
nofileerrors Disable reporting of file errors.
nogc Disable garbage collection.
nolog Disable logging.
T T
T T
T T
T T
nonvar(T) Term T is a non-variable.
P P
P P
P P
P P
nospy P Remove spy-points from the procedure(s) specified by P.
T M N T M N
T M N T M N
T M N T M N
T M N T M N
numbervars(T,M,N) Number the variables in term T from M to N-1.
P T A A T P
P T A A T P
P T A A T P
P T A A T P
op(P,T,A) Make atom A an operator of type T precedence P.
P L L P
P L L P
P L L P
P L L P
phrase(P,L) List L can be parsed as a phrase of type P.
T T
T T
T T
T T
portray(T) Portray term T according to the user supplied procedure.
T T
T T
T T
T T
print(T) Portray or else write the term T.
A B A B
A B A B
A B A B
A B A B
prompt(A,B) Change the prompt from A to B.
C C
C C
C C
C C
put(C) The next character output is C.
T T
T T
T T
T T
read(T) Read term T.
F F
F F
F F
F F
reconsult(F) Update the interpreted program with procedures from file F.
K T R T K R
K T R T K R
K T R T K R
K T R T K R
recorda(K,T,R) Make term T the first record under key K, reference R.
K T R T K R
K T R T K R
K T R T K R
K T R T K R
recorded(K,T,R) Term T is recorded under key K, reference R.
K T R T K R
K T R T K R
K T R T K R
K T R T K R
recordz(K,T,R) Make term T the last record under key K, reference R.
F G F G
F G F G
F G F G
F G F G
rename(F,G) Rename file F to G.
repeat Succeed repeatedly.
S S
S S
S S
S S
restore(S) Restore the state saved in file S.
C C
C C
C C
C C
retract(C) Erase the first interpreted clause of form C.
F N F N
F N F N
F N F N
F N F N
revive(F,N) Revive the latest compiled procedure named F arity N.
S S
S S
S S
S S
save(S) Save the current state of Prolog in file S.
F F
F F
F F
F F
see(F) Make file F the current input stream.
F F
F F
F F
F F
seeing(F) The current input stream is named F.
seen Close the current input stream.
X P S X P S
X P S X P S
X P S X P S
X P S X P S
setof(X,P,S) The set of instances of X such that P is provable is S.
C C
C C
C C
C C
skip(C) Skip input characters until after character C.
L S L S
L S L S
L S L S
L S L S
sort(L,S) The list L sorted into order yields S.
P P
P P
P P
P P
spy P Set spy-points on the procedure(s) specified by P.
statistics Output various execution statistics.
K V K V
K V K V
K V K V
K V K V
statistics(K,V) The execution statistic key K has value V.
G G
G G
G G
G G
subgoal←of(G) An ancestor goal of the current clause is G.
N N
N N
N N
N N
tab(N) Output N spaces.
F F
F F
F F
F F
tell(F) Make file F the current output stream.
F F
F F
F F
F F
telling(F) The current output stream is named F.
told Close the current output stream.
trace Switch on debugging and start tracing immediately.
trimcore Reduce free stack space to a minimum.
true Succeed.
ttyflush Transmit all outstanding terminal output.
16
C C
C C
C C
C C
ttyget(C) The next non-blank character input from the terminal is C.
C C
C C
C C
C C
ttyget0(C) The next character input from the terminal is C.
ttynl Output a new line on the terminal.
C C
C C
C C
C C
ttyput(C) The next character output to the terminal is C.
C C
C C
C C
C C
ttyskip(C) Skip over terminal input until after character C.
N N
N N
N N
N N
ttytab(N) Output N spaces to the terminal.
T T
T T
T T
T T
var(T) Term T is a variable.
T T
T T
T T
T T
write(T) Write the term T.
T T
T T
T T
T T
writeq(T) Write the term T, quoting names where necessary.
'LC' The following Prolog text uses lower case.
'NOLC' The following Prolog text uses upper case only.
! Cut any choices taken in the current procedure.
P P
P P
P P
P P
\+ P Goal P is not provable.
X P X P
X P X P
X P X P
X P X P
X↑P There exists an X such that P is provable.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X<Y As integer values, X is less than Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X=<Y As integer values, X is less than or equal to Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X>Y As integer values, X is greater than Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X>=Y As integer values, X is greater than or equal to Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X=Y Terms X and Y are equal (ie. unified).
T L T L
T L T L
T L T L
T L T L
T=..L The functor and arguments of term T comprise the list L.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X==Y Terms X and Y are strictly identical.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X\==Y Terms X and Y are not strictly identical.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X@<Y Term X precedes term Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X@=<Y Term X precedes or is identical to term Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X@>Y Term X follows term Y.
X Y X Y
X Y X Y
X Y X Y
X Y X Y
X@>=Y Term X follows or is identical to term Y.
F R F R
F R F R
F R F R
F R F R
[F|R] Perform the (re)consult(s) specified by [F|R].
Table of Contents
Table of Contents
Table of Contents
Table of Contents
Table of Contents
1. SUMMARY 1
2. INCOMPATIBLE CHANGES 1
3. THE INCORE COMPILER 2
3.1. Calling the Compiler 2
3.2. Public Declarations 2
3.3. Mode Declarations 3
3.4. Indexing 3
3.5. Tail Recursion Optimisation 4
3.6. Practical Limitations 4
4. PROGRAM DEVELOPMENT AIDS 4
5. OTHER NEW FEATURES 5
5.1. Initialisation File 5
5.2. Terminal prompts 5
5.3. End of Line Comments 5
5.4. Handling of Line Terminators 5
5.5. End of File Marker 5
6. NEW OPERATORS 6
7. NEW EVALUABLE PREDICATES 6
7.1. Compiled Program 6
7.2. Interpreted Program etc. 7
7.3. Internal Database 8
7.4. Meta-Logical 8
7.5. Comparison of Terms 10
7.6. Input-Output 11
7.7. Environmental 12
7.8. Debugging 12
7.9. Pre-Processing 13
7.10. Grammars 13
8. GLOSSARY OF CURRENT EVALUABLE PREDICATES 14